Python FastAPI ದೋಷ ನಿರ್ವಹಣೆ: ದೃಢವಾದ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ನಿರ್ಮಿಸುವುದು

ದೋಷ ನಿರ್ವಹಣೆಯು ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ API ಗಳನ್ನು ನಿರ್ಮಿಸುವಲ್ಲಿ ಒಂದು ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ. Python ನ FastAPI ನಲ್ಲಿ, ದೋಷಗಳನ್ನು ಸೊಗಸಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ತಿಳಿವಳಿಕೆ ನೀಡುವ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸಲು ನೀವು ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ಬಳಸಬಹುದು. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ FastAPI ನಲ್ಲಿ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು ಏಕೆ?

FastAPI ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಡೀಫಾಲ್ಟ್ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಮಾತ್ರ ಅವಲಂಬಿಸುವುದರಿಂದ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಅಸ್ಪಷ್ಟ ಅಥವಾ ನಿಷ್ಪ್ರಯೋಜಕ ಮಾಹಿತಿಯನ್ನು ನೀಡಬಹುದು. ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತಾರೆ:

• ಸುಧಾರಿತ ಬಳಕೆದಾರ ಅನುಭವ: ನಿರ್ದಿಷ್ಟ ದೋಷ ಸನ್ನಿವೇಶಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಸ್ಪಷ್ಟ ಮತ್ತು ತಿಳಿವಳಿಕೆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ.
• ಕೇಂದ್ರೀಕೃತ ದೋಷ ನಿರ್ವಹಣೆ: ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾಗುವಂತೆ ಮಾಡಲು, ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣಾ ತರ್ಕವನ್ನು ಕ್ರೋಢೀಕರಿಸಿ.
• ಸ್ಥಿರ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಗಳು: ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಗಳು ಸ್ಥಿರ ಸ್ವರೂಪವನ್ನು ಅನುಸರಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, API ಉಪಯುಕ್ತತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
• ವರ್ಧಿತ ಸುರಕ್ಷತೆ: ದೋಷ ಸಂದೇಶಗಳಲ್ಲಿ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದನ್ನು ತಡೆಯಿರಿ.
• ಕಸ್ಟಮ್ ಲಾಗಿಂಗ್: ದೋಷನಿವಾರಣೆ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ವಿವರವಾದ ದೋಷ ಮಾಹಿತಿಯನ್ನು ಲಾಗ್ ಮಾಡಿ.

FastAPI ಯ ವಿನಾಯಿತಿ ನಿರ್ವಹಣೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

FastAPI ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸಲು Python ನ ಅಂತರ್ನಿರ್ಮಿತ ವಿನಾಯಿತಿ ನಿರ್ವಹಣಾ ಕಾರ್ಯವಿಧಾನಗಳು ಮತ್ತು ಅದರ ಸ್ವಂತ ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ವ್ಯವಸ್ಥೆಯ ಸಂಯೋಜನೆಯನ್ನು ಬಳಸುತ್ತದೆ. ಒಂದು ಮಾರ್ಗ ಅಥವಾ ಅವಲಂಬನೆಯೊಳಗೆ ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದಾಗ, ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು FastAPI ಸೂಕ್ತವಾದ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕವನ್ನು ಹುಡುಕುತ್ತದೆ.

ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು @app.exception_handler() ನೊಂದಿಗೆ ಅಲಂಕರಿಸಲ್ಪಟ್ಟ ಕಾರ್ಯಗಳಾಗಿವೆ, ಇದು ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ವಿನಾಯಿತಿ ಪ್ರಕಾರ ಮತ್ತು ವಿನಂತಿಯ ವಸ್ತು. ಸೂಕ್ತವಾದ HTTP ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ನಿರ್ವಾಹಕರು ಹೊಂದಿದ್ದಾರೆ.

ಕಸ್ಟಮ್ ವಿನಾಯಿತಿಗಳನ್ನು ರಚಿಸುವುದು

ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೊದಲು, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ದೋಷ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ತರಗತಿಗಳನ್ನು ರಚಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ. ಇದು ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಮತ್ತು ವಿವಿಧ ರೀತಿಯ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ನೀವು ಇ-ಕಾಮರ್ಸ್ API ಅನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ ಮತ್ತು ಉತ್ಪನ್ನವು ಸ್ಟಾಕ್‌ನಿಂದ ಹೊರಗಿರುವ ಸಂದರ್ಭಗಳನ್ನು ನೀವು ನಿರ್ವಹಿಸಬೇಕಾಗಿದೆ. ನೀವು OutOfStockError ಎಂಬ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

            
class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

            

              
                Copy
              
            
          

ಈ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ವರ್ಗವು ಬೇಸ್ Exception ವರ್ಗದಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು product_id ಗುಣಲಕ್ಷಣ ಮತ್ತು ಕಸ್ಟಮ್ ದೋಷ ಸಂದೇಶವನ್ನು ಒಳಗೊಂಡಿದೆ.

ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

ಈಗ, OutOfStockError ಗಾಗಿ ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕವನ್ನು ರಚಿಸೋಣ. ಈ ನಿರ್ವಾಹಕನು ವಿನಾಯಿತಿಯನ್ನು ಹಿಡಿಯುತ್ತಾನೆ ಮತ್ತು ದೋಷ ಸಂದೇಶವನ್ನು ಹೊಂದಿರುವ JSON ದೇಹದೊಂದಿಗೆ HTTP 400 (ಬ್ಯಾಡ್ ರಿಕ್ವೆಸ್ಟ್) ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತಾನೆ.

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

class OutOfStockError(Exception):
    def __init__(self, product_id: int):
        self.product_id = product_id
        self.message = f"Product with ID {product_id} is out of stock."

@app.exception_handler(OutOfStockError)
async def out_of_stock_exception_handler(request: Request, exc: OutOfStockError):
    return JSONResponse(
        status_code=400,
        content={"message": exc.message},
    )

@app.get("/products/{product_id}")
async def get_product(product_id: int):
    # Simulate checking product stock
    if product_id == 123:
        raise OutOfStockError(product_id=product_id)
    return {"product_id": product_id, "name": "Example Product", "price": 29.99}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, @app.exception_handler(OutOfStockError) ಅಲಂಕಾರಿಕವು OutOfStockError ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು out_of_stock_exception_handler ಕಾರ್ಯವನ್ನು ನೋಂದಾಯಿಸುತ್ತದೆ. get_product ಮಾರ್ಗದಲ್ಲಿ OutOfStockError ಅನ್ನು ಎತ್ತಿದಾಗ, ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ನಂತರ ನಿರ್ವಾಹಕರು 400 ಸ್ಥಿತಿ ಕೋಡ್ ಮತ್ತು ದೋಷ ಸಂದೇಶವನ್ನು ಹೊಂದಿರುವ JSON ದೇಹದೊಂದಿಗೆ JSONResponse ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತಾನೆ.

ಬಹು ವಿನಾಯಿತಿ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ವಿವಿಧ ರೀತಿಯ ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನೀವು ಬಹು ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವಾಗ ಸಂಭವಿಸುವ ValueError ವಿನಾಯಿತಿಗಳನ್ನು ನೀವು ನಿರ್ವಹಿಸಲು ಬಯಸಬಹುದು.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.exception_handler(ValueError)
async def value_error_exception_handler(request: Request, exc: ValueError):
    return JSONResponse(
        status_code=400,
        content={"message": str(exc)},
    )

@app.get("/items/{item_id}")
async def get_item(item_id: int):
    # Simulate invalid item_id
    if item_id < 0:
        raise ValueError("Item ID must be a positive integer.")
    return {"item_id": item_id, "name": "Example Item"}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, value_error_exception_handler ಕಾರ್ಯವು ValueError ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ವಿನಾಯಿತಿ ವಸ್ತುವಿನಿಂದ ದೋಷ ಸಂದೇಶವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು JSON ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

HTTPException ಅನ್ನು ಬಳಸುವುದು

FastAPI ಎಂಬುದು HTTPException ಎಂಬ ಅಂತರ್ನಿರ್ಮಿತ ವಿನಾಯಿತಿ ವರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದನ್ನು HTTP-ನಿರ್ದಿಷ್ಟ ದೋಷಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ಬಳಸಬಹುದು. ಇದು ಅನಧಿಕೃತ ಪ್ರವೇಶ ಅಥವಾ ಸಂಪನ್ಮೂಲ ಕಂಡುಬಂದಿಲ್ಲದಂತಹ ಸಾಮಾನ್ಯ ದೋಷ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉಪಯುಕ್ತವಾಗಬಹುದು.

            
from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Simulate user not found
    if user_id == 999:
        raise HTTPException(status_code=404, detail="User not found")
    return {"user_id": user_id, "name": "Example User"}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, HTTPException ಅನ್ನು 404 (ಕಂಡುಬಂದಿಲ್ಲ) ಸ್ಥಿತಿ ಕೋಡ್ ಮತ್ತು ವಿವರ ಸಂದೇಶದೊಂದಿಗೆ ಎತ್ತಲಾಗುತ್ತದೆ. FastAPI ಸ್ವಯಂಚಾಲಿತವಾಗಿ HTTPException ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಥಿತಿ ಕೋಡ್ ಮತ್ತು ವಿವರ ಸಂದೇಶದೊಂದಿಗೆ JSON ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು

ನೀವು ನಿರ್ವಹಿಸದ ಎಲ್ಲಾ ವಿನಾಯಿತಿಗಳನ್ನು ಹಿಡಿಯುವ ಜಾಗತಿಕ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರನ್ನು ಸಹ ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ದೋಷಗಳನ್ನು ಲಾಗ್ ಮಾಡಲು ಅಥವಾ ಕ್ಲೈಂಟ್‌ಗೆ ಸಾಮಾನ್ಯ ದೋಷ ಸಂದೇಶವನ್ನು ಹಿಂದಿರುಗಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    logger.exception(f"Unhandled exception: {exc}")
    return JSONResponse(
        status_code=500,
        content={
            "message": "Internal server error",
        },
    )

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, global_exception_handler ಕಾರ್ಯವು ಇತರ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು ನಿರ್ವಹಿಸದ ಎಲ್ಲಾ ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ದೋಷವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ದೋಷ ಸಂದೇಶದೊಂದಿಗೆ 500 (ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ) ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ವಿನಾಯಿತಿ ನಿರ್ವಹಣೆಗಾಗಿ ಮಧ್ಯಂತರ ತಂತ್ರಾಂಶವನ್ನು ಬಳಸುವುದು

ವಿನಾಯಿತಿ ನಿರ್ವಹಣೆಗೆ ಮತ್ತೊಂದು ವಿಧಾನವೆಂದರೆ ಮಧ್ಯಂತರ ತಂತ್ರಾಂಶವನ್ನು ಬಳಸುವುದು. ಪ್ರತಿ ವಿನಂತಿಯ ಮೊದಲು ಮತ್ತು ನಂತರ ಮಧ್ಯಂತರ ತಂತ್ರಾಂಶ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಹೆಚ್ಚಿನ ಮಟ್ಟದಲ್ಲಿ ವಿನಾಯಿತಿಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ವಿನಂತಿಗಳು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಲಾಗ್ ಮಾಡುವಂತಹ ಕಾರ್ಯಗಳಿಗಾಗಿ ಅಥವಾ ಕಸ್ಟಮ್ ದೃಢೀಕರಣ ಅಥವಾ ದೃಢೀಕರಣ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

            
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging

app = FastAPI()

logger = logging.getLogger(__name__)

@app.middleware("http")
async def exception_middleware(request: Request, call_next):
    try:
        response = await call_next(request)
    except Exception as exc:
        logger.exception(f"Unhandled exception: {exc}")
        return JSONResponse(
            status_code=500,
            content={
                "message": "Internal server error",
            },
        )
    return response

@app.get("/error")
async def trigger_error():
    raise ValueError("This is a test error.")

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, exception_middleware ಕಾರ್ಯವು ವಿನಂತಿ ಸಂಸ್ಕರಣಾ ತರ್ಕವನ್ನು try...except ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸುತ್ತುತ್ತದೆ. ವಿನಂತಿ ಸಂಸ್ಕರಣೆಯ ಸಮಯದಲ್ಲಿ ವಿನಾಯಿತಿಯನ್ನು ಎತ್ತಿದರೆ, ಮಧ್ಯಂತರ ತಂತ್ರಾಂಶವು ದೋಷವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ ಮತ್ತು 500 (ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ) ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಮತ್ತು ದೋಷ ಸಂದೇಶಗಳು

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ API ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ, ನಿಮ್ಮ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಅಂತರರಾಷ್ಟ್ರೀಯಗೊಳಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಇದು ಬಳಕೆದಾರರ ಸ್ಥಳದ ಆಧಾರದ ಮೇಲೆ ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಸಂಪೂರ್ಣ i18n ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಈ ಲೇಖನದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮೀರಿದ್ದರೂ, ಪರಿಕಲ್ಪನೆಯನ್ನು ಪ್ರದರ್ಶಿಸುವ ಸರಳೀಕೃತ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

            
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse
from typing import Dict

app = FastAPI()

# Mock translation dictionary (replace with a real i18n library)
translations: Dict[str, Dict[str, str]] = {
    "en": {
        "product_not_found": "Product with ID {product_id} not found.",
        "invalid_input": "Invalid input: {error_message}",
    },
    "fr": {
        "product_not_found": "Produit avec l'ID {product_id} introuvable.",
        "invalid_input": "Entrée invalide : {error_message}",
    },
    "es": {
        "product_not_found": "Producto con ID {product_id} no encontrado.",
        "invalid_input": "Entrada inválida: {error_message}",
    },
    "de": {
        "product_not_found": "Produkt mit ID {product_id} nicht gefunden.",
        "invalid_input": "Ungültige Eingabe: {error_message}",
    }
}

def get_translation(locale: str, key: str, **kwargs) -> str:
    """Retrieves a translation for a given locale and key.
    If the locale or key is not found, returns a default message.
    """
    if locale in translations and key in translations[locale]:
        return translations[locale][key].format(**kwargs)
    return f"Translation missing for key '{key}' in locale '{locale}'."

@app.get("/products/{product_id}")
async def get_product(request: Request, product_id: int, locale: str = "en"):
    # Simulate product lookup
    if product_id > 100:
        message = get_translation(locale, "product_not_found", product_id=product_id)
        raise HTTPException(status_code=404, detail=message)

    if product_id < 0:
         message = get_translation(locale, "invalid_input", error_message="Product ID must be positive")
         raise HTTPException(status_code=400, detail=message)

    return {"product_id": product_id, "name": "Example Product"}

            

              
                Copy
              
            
          

i18n ಉದಾಹರಣೆಗಾಗಿ ಮುಖ್ಯ ಸುಧಾರಣೆಗಳು:

• ಸ್ಥಳ ಪ್ಯಾರಾಮೀಟರ್: ಮಾರ್ಗವು ಈಗ locale ಪ್ರಶ್ನೆ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಇದು ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ತಮ್ಮ ಆದ್ಯತೆಯ ಭಾಷೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅನುಮತಿಸುತ್ತದೆ (ಇಂಗ್ಲಿಷ್‌ಗಾಗಿ "en" ಗೆ ಡೀಫಾಲ್ಟ್ ಆಗಿರುತ್ತದೆ).
• ಅನುವಾದ ನಿಘಂಟು: translations ನಿಘಂಟು (ಮಾದರಿ) ವಿವಿಧ ಸ್ಥಳಗಳಿಗೆ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇಂಗ್ಲಿಷ್, ಫ್ರೆಂಚ್, ಸ್ಪ್ಯಾನಿಷ್, ಜರ್ಮನ್). ನಿಜವಾದ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ನೀವು ಮೀಸಲಾದ i18n ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತೀರಿ.
• get_translation ಕಾರ್ಯ: ಈ ಸಹಾಯ ಕಾರ್ಯವು locale ಮತ್ತು key ಆಧಾರದ ಮೇಲೆ ಸೂಕ್ತವಾದ ಅನುವಾದವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ಇದು ಡೈನಾಮಿಕ್ ಮೌಲ್ಯಗಳನ್ನು (ಉದಾಹರಣೆಗೆ product_id) ಸೇರಿಸಲು ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ.
• ಡೈನಾಮಿಕ್ ದೋಷ ಸಂದೇಶಗಳು: HTTPException ಈಗ get_translation ಕಾರ್ಯವನ್ನು ಬಳಸಿ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಉತ್ಪಾದಿಸಲಾದ detail ಸಂದೇಶದೊಂದಿಗೆ ಎತ್ತಲಾಗುತ್ತದೆ.

ಒಂದು ಕ್ಲೈಂಟ್ /products/101?locale=fr ಅನ್ನು ವಿನಂತಿಸಿದಾಗ, ಅವರು ಫ್ರೆಂಚ್‌ನಲ್ಲಿ ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ (ಅನುವಾದ ಲಭ್ಯವಿದ್ದರೆ). /products/-1?locale=es ಅನ್ನು ವಿನಂತಿಸಿದಾಗ, ಅವರು ಋಣಾತ್ಮಕ ID ಬಗ್ಗೆ ಸ್ಪ್ಯಾನಿಷ್‌ನಲ್ಲಿ ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ (ಲಭ್ಯವಿದ್ದರೆ). /products/200?locale=xx (ಅನುವಾದಗಳಿಲ್ಲದ ಸ್ಥಳ) ವಿನಂತಿಸುವಾಗ, ಅವರು `Translation missing` ಸಂದೇಶವನ್ನು ಪಡೆಯುತ್ತಾರೆ.

ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

FastAPI ನಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಕಸ್ಟಮ್ ವಿನಾಯಿತಿಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ದೋಷ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ತರಗತಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.
• ಮಾಹಿತಿಯುಕ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ: ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ದೋಷದ ಕಾರಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವ ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಸೇರಿಸಿ.
• ಸೂಕ್ತವಾದ HTTP ಸ್ಥಿತಿ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸಿ: ದೋಷದ ಸ್ವರೂಪವನ್ನು ನಿಖರವಾಗಿ ಪ್ರತಿಬಿಂಬಿಸುವ HTTP ಸ್ಥಿತಿ ಕೋಡ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸಿ. ಉದಾಹರಣೆಗೆ, ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್‌ಗಾಗಿ 400 (ಬ್ಯಾಡ್ ರಿಕ್ವೆಸ್ಟ್), ಕಾಣೆಯಾದ ಸಂಪನ್ಮೂಲಗಳಿಗಾಗಿ 404 (ಕಂಡುಬಂದಿಲ್ಲ) ಮತ್ತು ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳಿಗಾಗಿ 500 (ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ) ಬಳಸಿ.
• ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ: ದೋಷ ಸಂದೇಶಗಳಲ್ಲಿ ಡೇಟಾಬೇಸ್ ರುಜುವಾತುಗಳು ಅಥವಾ API ಕೀಗಳಂತಹ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿಯನ್ನು ಬಹಿರಂಗಪಡಿಸದಂತೆ ಎಚ್ಚರಿಕೆ ವಹಿಸಿ.
• ಲಾಗ್ ದೋಷಗಳು: ದೋಷನಿವಾರಣೆ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆ ಉದ್ದೇಶಗಳಿಗಾಗಿ ವಿವರವಾದ ದೋಷ ಮಾಹಿತಿಯನ್ನು ಲಾಗ್ ಮಾಡಿ. Python ನ ಅಂತರ್ನಿರ್ಮಿತ logging ಮಾಡ್ಯೂಲ್‌ನಂತಹ ಲಾಗಿಂಗ್ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿ.
• ದೋಷ ನಿರ್ವಹಣಾ ತರ್ಕವನ್ನು ಕೇಂದ್ರೀಕರಿಸಿ: ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು ಅಥವಾ ಮಧ್ಯಂತರ ತಂತ್ರಾಂಶದಂತಹ ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ದೋಷ ನಿರ್ವಹಣಾ ತರ್ಕವನ್ನು ಕ್ರೋಢೀಕರಿಸಿ.
• ನಿಮ್ಮ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ದೋಷ ನಿರ್ವಹಣಾ ತರ್ಕವು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ.
• ಮೀಸಲಾದ ದೋಷ ಟ್ರ್ಯಾಕಿಂಗ್ ಸೇವೆಯನ್ನು ಬಳಸುವುದು ಪರಿಗಣಿಸಿ: ಉತ್ಪಾದನಾ ಪರಿಸರಗಳಿಗಾಗಿ, ದೋಷಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮತ್ತು ವಿಶ್ಲೇಷಿಸಲು Sentry ಅಥವಾ Rollbar ನಂತಹ ಮೀಸಲಾದ ದೋಷ ಟ್ರ್ಯಾಕಿಂಗ್ ಸೇವೆಯನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಪರಿಕರಗಳು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಆರೋಗ್ಯದ ಬಗ್ಗೆ ಮೌಲ್ಯಯುತವಾದ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸಬಹುದು ಮತ್ತು ಸಮಸ್ಯೆಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸಲು ಮತ್ತು ಪರಿಹರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ತೀರ್ಮಾನ

FastAPI ನಲ್ಲಿ ದೃಢವಾದ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ API ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ನಿರ್ವಾಹಕರು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಕಸ್ಟಮ್ ವಿನಾಯಿತಿ ತರಗತಿಗಳು ಮತ್ತು ನಿರ್ವಾಹಕರನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನೀವು ದೋಷಗಳನ್ನು ಸೊಗಸಾಗಿ ನಿರ್ವಹಿಸಬಹುದು, ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ತಿಳಿವಳಿಕೆ ನೀಡುವ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಒಟ್ಟಾರೆ ವಿಶ್ವಾಸಾರ್ಹತೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಕಸ್ಟಮ್ ವಿನಾಯಿತಿಗಳು, HTTPExceptions ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು ಮತ್ತು ಅನ್ವಯವಾಗುವಲ್ಲಿ i18n ತತ್ವಗಳನ್ನು ಬಳಸುವುದು ಜಾಗತಿಕ ಯಶಸ್ಸಿಗಾಗಿ ನಿಮ್ಮ API ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ.

ನಿಮ್ಮ ದೋಷ ನಿರ್ವಹಣಾ ತಂತ್ರವನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯಬೇಡಿ. ಸಮಸ್ಯೆ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಬೇಕೆಂದು ಬಳಕೆದಾರರಿಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವ ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಒದಗಿಸಿ. ಪರಿಣಾಮಕಾರಿ ದೋಷ ನಿರ್ವಹಣೆಯು ವೈವಿಧ್ಯಮಯ ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರ ಅಗತ್ಯತೆಗಳನ್ನು ಪೂರೈಸುವ ಉತ್ತಮ ಗುಣಮಟ್ಟದ API ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಾಧಾರವಾಗಿದೆ.